home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 178_01 / tvx_1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-01-16  |  33.7 KB  |  1,288 lines
  1. /* ------------------------ tvx_1.c ------------------------------------- */
  2. /* ========================================================================
  3.  
  4.     TVX - A full screen editor in C
  5.  
  6.     Originally developed by:
  7.  
  8.         Dr. Bruce E. Wampler
  9.         University of New Mexico
  10.         Department of Computer Science
  11.         Farris Engineering Center
  12.         Albuquerque, NM 87131
  13.  
  14.         uucp:   ..{ucbvax | gatech | ihnp4!lanl}!unmvax!wampler
  15.  
  16.     Public Domain version released July 1, 1985
  17.         Direct comments, bug reports, suggestions to
  18.         Bruce Wampler at above address.
  19.  
  20.     Converted from Ratfor to C January 1981 (note: since the editor
  21.         was originally in Ratfor, there are certain remnants of the
  22.         original structure left over.  There are a lot of things that
  23.         could have been done better if written in C originally.
  24.         Note also that this editor was originally designed in
  25.         1979 when TECO was state of the art.  The influence of
  26.         TECO on this editor will be apparent to anyone who has
  27.         used TECO.
  28.  
  29.         So it goes.
  30.  
  31.  
  32.     PLEASE! If you are making additional modifications, use the
  33.         indentation scheme used here (line up {,}'s!!!) instead
  34.         of the unmaintainable indentation used by K&R!.
  35.         Also, please mark your changes with initials and date!
  36.  
  37.     Description of files required: (names lower case on unix)
  38.  
  39.     TVX_1.C       - main part of code (part 1), mostly os/terminal independent
  40.     TVX_2.C       - main part of code (part 2), mostly os/terminal independent
  41.     TVX_LEX.C  - defaults, some os dependent stuff in here.  Major
  42.              changes in defaults can be fixed by recompiling this file.
  43.     TVX_IO.C   - almost all I/O, including screen, confined to this file.
  44.     TVX_LIB.C  - misc library routines needed by TVX.
  45.     TVX_IBM.C  - IBM-PC specific code, specifically the screen driver
  46.       (TVX_IBM.ASM - hand optimized version of TVX_IBM.C)
  47.     TVX_UNIX.C - contains unix specific code, including termcap driver
  48.     TVX_CFG.C  - used to build CONFIG.TVX file for -c switch
  49.         TVX_PTCH.C - used to permanently patch tvx with config file
  50.  
  51.     TVX_DEFS.IC - #define's for version, os, terminal, defaults
  52.         TVX_GLBL.IC - global data structures
  53.     TVX_TERM.IC - definitions for various terminals and systems
  54.  
  55.     Most distributions will contain other useful files as well.
  56.  
  57. ============================================================================ */
  58.  
  59. #include "tvx_defs.ic"        /* note tv_defs.ic will #include stdio.h */
  60. #include "tvx_glbl.ic"
  61.  
  62. /* =============================>>> MAIN <<<============================= */
  63.   main (argc,argv)
  64.   int argc;
  65.   char *argv[];
  66.   {
  67.  
  68.     checkos();        /* check operating system version */
  69.     force_tty = FALSE;    /* won't usually force tty mode */
  70.  
  71.     tvinit();
  72.     ttinit();        /* initialize tt: */
  73.     trmini();        /* init terminal if needed */
  74.     csrcmd();        /* make cursor command cursor */
  75.  
  76.     fopenx(argc,argv);    /* open the file, maybe change switches */
  77.  
  78.     tvidefs();        /* set defaults */
  79.     opnbak();        /* may or may not be null routine */
  80.  
  81.     edit();        /* edit the file */
  82.  
  83.     clobak();        /* may be null routine */
  84.  
  85.     file_exit();    /* clean up files */
  86.  
  87.     ttymode = FALSE;
  88.  
  89.     if (*dest_file)
  90.     remark(dest_file);    /* echo final file name */
  91.     else
  92.       {
  93.     prompt("R/O, no changes: ") ; remark(orig_file);
  94.       }
  95.  
  96.     reset();        /* reset anything necessary */
  97.     quit();
  98.   }
  99.  
  100. /* =============================>>> ASK <<<============================= */
  101.   ask(msg,rply,rcnt)
  102.   char *msg,*rply;
  103.   int rcnt;
  104.   {            /* get a reply, via tty if necessary */
  105.     int oldtty;
  106.  
  107.     oldtty = ttymode;
  108.     ttymode = FALSE;    /* force echo on */
  109.     prompt(msg);
  110.     reply(rply,rcnt);
  111.     ttymode = oldtty;    /* back how it was */
  112.   }
  113.  
  114. /* =============================>>> BEGLIN <<<============================= */
  115.   beglin()
  116.   {  /* beglin - move cursor to beginning of current line */
  117.  
  118.     SLOW int xf;
  119.  
  120.     curchr = *(lines+curlin) + 1;    /* point to current character */
  121.     xf = findx();    /* this line needed to make the next */
  122.             /* call eval order independent, if you wondered */
  123.     tvxy(xf,tvy);    /* and move cursor */
  124.   }
  125.  
  126. /* =============================>>> BOTPAG <<<============================= */
  127.   botpag()
  128.   { /* botpag - move cursor to bottom of current page (buffer) */
  129.  
  130.     curlin = nxtlin-1;        /* the last real line of text */
  131.     curchr = *(lines+curlin) + 1; /* the first char of that line */
  132.     endlin();            /* goto end of the line */
  133.     newscr();            /* update the screen */
  134.   }
  135.  
  136. /* ============================>>> CHK_RPT_NR <<<============================ */
  137.   chk_rpt_nr(val)
  138.   int val;
  139.   {        /* see if val is in valid range */
  140.  
  141.     if (val < 0 || val > REPEATBUFS)    /* out of range */
  142.       {
  143.     tverrb("Bad rpt buff # ");
  144.     return (FALSE);
  145.       }
  146.     else
  147.     return (TRUE);
  148.   }
  149.  
  150. /* =============================>>> CMDERR <<<============================= */
  151.   cmderr(chr)
  152.   char chr;
  153.   {    /* cmderr - invalid command entered */
  154.  
  155.     static char badcmd[] = "Bad command:   ";
  156.  
  157.     if (chr >= ' ')
  158.       {
  159.     badcmd[13] = chr;     /* stick in after : */
  160.     badcmd[14] = ' ';
  161.       }
  162.     else
  163.       {
  164.     badcmd[13] = '^';
  165.     badcmd[14] = chr + '@';
  166.       }
  167.     tverrb(badcmd);
  168.   }
  169.  
  170. /* =============================>>> COMBIN <<<============================= */
  171.   combin()
  172.   { /* combin - combine current line with next line
  173.         update screen -    cursor assumed to be on curlin */
  174.  
  175.     SLOW int to,from,xf;
  176.     SLOW BUFFINDEX newl,k1,k2;
  177.  
  178.     if (curlin+1 >= nxtlin)        /* can't combine */
  179.     return (FALSE);
  180.     if (nxtsav-nxtchr < ALMOSTOUT)    /* check if need g.c. */
  181.     if (! gbgcol())
  182.         return (FALSE);
  183.     newl = nxtchr;            /* where next char goes */
  184.     stcopy(buff,*(lines+curlin),buff,&nxtchr); /* copy over current line */
  185.     curchr = nxtchr;            /* update the curchr */
  186.     k1 = *(lines+curlin);          /* we will kill this line */
  187.     *(lines+curlin) = newl;        /* remember where it is */
  188.     stcopy(buff,*(lines+curlin+1)+1,buff,&nxtchr); /* append the next line */
  189.     ++nxtchr;                /* fix nxtchr */
  190.     to = curlin+1;
  191.     k2 = *(lines+to);            /* we will kill this line */
  192.     for (from=curlin+2; from < nxtlin ; )    /* copy line to end */
  193.       {
  194.     *(lines+to++) = *(lines+from++);
  195.       }
  196.     --nxtlin;        /* update line ptr */
  197.     kline(k1);        /* kill the old lines now */
  198.     kline(k2);
  199.     if (tvdlin <= dsplin)    /* not at end of buffer */
  200.       {
  201.     tvescr();        /* erase rest of screen */
  202.     tvxy(1,tvy);    /* fix it up */
  203.     tvtype(curlin,min(tvlins-tvdlin+1,nxtlin-curlin));
  204.       }
  205.     else            /* at end of buffer */
  206.     newscr();
  207.  
  208.     xf = findx();
  209.     tvxy(xf,tvy); /* home cursor */
  210.  
  211.     return (TRUE);
  212.   }
  213.  
  214. /* =============================>>> CTRLCH <<<============================= */
  215.   ctrlch(chr)
  216.   char chr;
  217.   { /* ctrlch - echoes a control character for search and lex */
  218.  
  219.     if (chr >= ' ')
  220.     tvcout(chr);    /* echo as is */
  221.     else if (chr == CR)        /* carriage return may be special */
  222.       {
  223.     tvcout(CR);
  224. #ifdef USELF
  225.     tvcout(LF);    /*$$$ some machines need LF */
  226. #endif
  227.       }
  228.     else if (chr == ESC)    /* escape as $ */
  229.     tvcout('$');
  230.     else            /* echo most chars as '^x' */
  231.       {
  232.     tvcout('^');
  233.     tvcout(chr+'@');
  234.       }
  235.   }
  236.  
  237. /* =============================>>> DELNXT <<<============================= */
  238.   int delnxt(cnt)
  239.   int cnt;
  240.   {  /* delnxt - delete next n characters  */
  241.  
  242.     char clower();
  243.     static char chdel;
  244.     SLOW int abscnt,newx;
  245.     SLOW BUFFINDEX to;
  246.     SLOW char ans[2];
  247.     FAST int i;
  248.  
  249.     abscnt = cnt;    /* remember absolute value of cnt */
  250.     if (cnt > 100 || cnt < -100)        /* make sure about this! */
  251.       {
  252.     tvclr();
  253.     ask("Kill that many for sure? (y/n) ",ans,1);
  254.     verify(1);
  255.     if (clower(ans[0]) != 'y')
  256.         return (TRUE);
  257.        }
  258.  
  259.     if (cnt > 0)        /* deleting forewards */
  260.       {
  261.     chdel = *(buff+curchr); /* remember the char we are deleting */
  262.     for (i=1; curlin < nxtlin && i <= cnt; ++i) /* don't pass end of buff */
  263.       {
  264.         if (*(buff+curchr)==ENDLINE)    /* combine when end of line */
  265.           {
  266.         if (! combin())
  267.           {
  268.             return (FALSE);
  269.           }
  270.           }
  271.         else        /* deleting one character */
  272.           {
  273.         to=curchr;    /* overwrite current line */
  274.         stcopy(buff,curchr+1,buff,&to); /* copy the rest of the line */
  275.         for (++to; *(buff+to) != BEGLINE && to < nxtchr; ++to)
  276.             *(buff+to)=GARBAGE; /* mark the garbage characters */
  277.           }
  278.       }
  279.       }
  280.     else if (cnt < 0)        /* deleting backwards */
  281.       {
  282.     abscnt=(-cnt);
  283.     chdel = *(buff+curchr-1); /* remember the char we are deleting */
  284.     for (i=cnt; curlin >= 1 && i<0; ++i)    /* don't go past start */
  285.       {
  286.         if (*(buff+curchr-1)==BEGLINE)    /* deleting line separator */
  287.           {
  288.         if (curlin > 1)     /* not past beginning */
  289.           {
  290.             dwnlin(-1);        /* go up one line */
  291.             endlin();        /* get end of the line */
  292.             if (!combin())    /* and combine */
  293.               {
  294.             return (FALSE);
  295.               }
  296.           }
  297.           }
  298.         else            /* killing a normal character */
  299.           {
  300.         to=curchr-1;        /* overwrite in place */
  301.         stcopy(buff,curchr,buff,&to); /* copy the rest of the line */
  302.         for (++to; *(buff+to)!=BEGLINE && to < nxtchr; ++to)
  303.             *(buff+to)=GARBAGE; /* mark the garbage characters */
  304.         --curchr;
  305.           }
  306.       }
  307.       }
  308.     newx=findx();        /* where cursor will go */
  309.     tvxy(newx,tvy);        /* reposition cursor */
  310.     if (chdel < ' ' || abscnt != 1)
  311.     tvelin();        /* erase rest of the line */
  312.     else            /* need to check for tabs following */
  313.       {
  314.     for (i = curchr ; *(buff+i)!=ENDLINE ; ++i)
  315.         if (*(buff+i) < ' ')
  316.           {
  317.         tvelin();    /* need to erase the line */
  318.         break;
  319.           }
  320.       }
  321.     tvtyln(curchr);        /* retype the rest */
  322.     if (chdel >= ' ' && abscnt == 1 && last_col_out < tvcols)
  323.     tvcout(' ');        /* "erase" last char on line */
  324.     tvxy(newx,tvy);        /* restore the cursor */
  325.  
  326.     return (TRUE);
  327.   }
  328.  
  329. /* =============================>>> DWNCOL <<<============================= */
  330.   dwncol(cnt)
  331.   int cnt;
  332.   { /* dwncol - move down in column */
  333.  
  334.     SLOW int curcol,l,oldef,needns;
  335.  
  336.     needns = FALSE;
  337.     if (leftmg > 1)        /* handle right virtual screen different */
  338.       {
  339.     oldef=echof;
  340.     needns = TRUE;
  341.     echof = FALSE;
  342.       }
  343.  
  344.     if (oldlex==VDOWNCOL || oldlex==VUPCOL)    /* several in a row? */
  345.     curcol=oldcol;        /* pick up old value */
  346.     else
  347.       {
  348.     curcol = curchr - *(lines+curlin);    /* calculate the current column */
  349.     oldcol = curcol;
  350.       }
  351.     dwnlin(cnt);        /* go down given lines */
  352.     if (curlin>=1 && curlin<nxtlin && curcol>1)    /* not at ends? */
  353.       {
  354.     l = strlen(buff + ((*(lines+curlin)) + 1) );
  355.     right(min(curcol-1,l));
  356.       }
  357.  
  358.     if (needns)            /* needed new screen */
  359.       {
  360.     echof=oldef;
  361.     newscr();
  362.       }
  363.   }
  364.  
  365. /* =============================>>> DWNLIN <<<============================= */
  366.   dwnlin(cnt)
  367.   int cnt;
  368.   { /* dwnlin - move dot down cnt lines */
  369.  
  370.     SLOW int oldlin,change;
  371.  
  372.     if (curlin==nxtlin-1 && cnt > 0)    /* down from last line? */
  373.       {
  374.     endlin();
  375.     return;
  376.       }
  377.     oldlin=curlin;        /* remember where we started from */
  378.     curlin=max(min(curlin+cnt,nxtlin-1),1);    /* move down lines */
  379.     curchr = *(lines+curlin)+1;    /* point to the current character */
  380.     change=curlin-oldlin;    /* calculate how many lines changed */
  381.     update(change);        /* update the screen */
  382.  
  383.   }
  384.  
  385. /* =============================>>> EDIT   <<<============================= */
  386.   edit()
  387.   { /*    edit - main editing routine */
  388.  
  389.     SLOW int lexval,lexcnt,succ, lastln, itmp;
  390.     SLOW int noteloc[10], ni, lex_def;
  391.  
  392.     static int ins_set[] =
  393.       {
  394.     VINSERT, VOPENLINE, VQUIT, VABORT, VFBEGIN, VGET, VYANK, 0
  395.       };
  396.  
  397.     static int jump_set[] =    /* commands to not reset jump memory */
  398.       {
  399.     VJUMP, VMEMORY, VHELP, VNOTELOC, VPRINTS, 0
  400.       };
  401.  
  402.     static char lexchr;
  403.  
  404.     startm();
  405.     remark("Reading file...");
  406.  
  407.     rdpage();            /* read a page into the buffer */
  408.  
  409.     tvclr();            /* clear the screen */
  410.  
  411.     if (curlin >= 1)
  412.     tvtype(curlin,tvlins);    /* type out lines */
  413.  
  414.     tvxy(1,1);            /* and rehome the cursor */
  415.     waserr = FALSE;        /* no errors to erase yet */
  416.  
  417.     if (curlin<1)
  418.     tverr("Buffer empty");
  419.  
  420.     lexval = UNKNOWN;        /* so can remember 1st time through */
  421.     useprint = FALSE;        /* not to printer */
  422.     succ=TRUE;            /* assume success initially */
  423.  
  424.     lastln = curlin;        /* remember where we were */
  425.     for (ni = 0 ; ni < 10 ; noteloc[ni++] = curlin)
  426.     ;            /* init noteloc */
  427.     do
  428.       {
  429.     oldlex = lexval;        /* remember last command */
  430.     if (! succ)
  431.         echof = TRUE;        /* resume echo when error */
  432.     lex_def = lex(&lexval,&lexcnt,&lexchr,succ);    /* get command input */
  433.     if (waserr)
  434.         fixend();
  435.     waserr=FALSE;
  436.     succ=TRUE;
  437.     if (lexval == UNKNOWN)
  438.       {
  439.         cmderr(lexchr);
  440.         succ = FALSE;    /* announce failure to lex */
  441.       }
  442.     else
  443.       {
  444.         if (curlin < 1)    /* make sure legal command for empty buffer */
  445.           {
  446.  
  447.         if (!inset(lexval,ins_set))
  448.           {
  449.             tverrb("Can't, buffer empty. Insert 1st ");
  450.             succ=FALSE;
  451.             continue;
  452.           }
  453.           }
  454.         if (!inset(lexval,jump_set))
  455.         lastln=curlin;        /* let user look at help w/o changing */
  456.  
  457.         switch (lexval)
  458.         {
  459. case 1:             /* right */
  460.         right(lexcnt);
  461.         break;
  462. case 2:             /* left */
  463.         right(-lexcnt);
  464.         break;
  465. case 3:             /* down line */
  466.         dwnlin(lexcnt);
  467.         break;
  468. case 4:             /* up line */
  469.         dwnlin(-lexcnt);
  470.         break;
  471. case 5:             /* down in column */
  472.         dwncol(lexcnt);
  473.         break;
  474. case 6:             /* up in column */
  475.         dwncol(-lexcnt);
  476.         break;
  477. case 7:             /* delete last character */
  478.         succ = delnxt(-lexcnt);
  479.         break;
  480. case 8:             /* delete next character */
  481.         succ = delnxt(lexcnt);
  482.         break;
  483. case 9:             /* insert */
  484.         succ = insert(lexcnt,lex_def);
  485.         break;
  486. case 10:            /* kill a line */
  487.         killin(lexcnt);
  488.         break;
  489. case 11:            /* kill rest of line */
  490.         krest();
  491.         break;
  492. case 12:            /* kill previous part of line */
  493.         kprev();
  494.         break;
  495. case 13:            /* move to beginning of line */
  496.         beglin();
  497.         break;
  498. case 14:            /* move to end of the line */
  499.         endlin();
  500.         break;
  501. case 15:            /* search for a pattern */
  502.         succ = search(lexcnt,TRUE);
  503.         break;
  504. case 16:            /* search for next part of a pattern */
  505.         succ = snext(lexcnt,TRUE);
  506.         break;
  507. case 17:            /* flip screen */
  508.         dwnlin(min(lexcnt*tvlins,nxtlin-curlin+1));
  509.         break;
  510. case 18:            /* goto top of page */
  511.         toppag();
  512.         break;
  513. case 19:            /* goto to bottom of page */
  514.         botpag();
  515.         break;
  516. case 20:            /* goto real beginning of the file */
  517.         succ = fbeg();
  518.         break;
  519. case 21:            /* verify */
  520.         verify(lexcnt);
  521.         break;
  522. case 22:            /* open new line */
  523.         openln(lexcnt);
  524.         succ = insert(1,TRUE); /* go into insert mode, insert mode */
  525.         break;
  526. case 23:            /* delete last thing manipulated */
  527.         succ = rmvlst();
  528.         break;
  529. case 24:            /* save lines in move buffer */
  530.         succ = save(lexcnt,FALSE);
  531.         break;
  532. case 25:            /* get move buffer */
  533.         succ = getsav();
  534.         break;
  535. case 26:            /* read in next page of file */
  536.         wtpage(lexcnt);    /* write out the current page */
  537.         succ = rdpage();    /* read in the next */
  538.         tvclr();
  539.         if (succ || lexcnt < 0)
  540.         verify(1);
  541.         break;
  542. case 27:            /* append external file to save buffer */
  543.         succ = addfil(lexcnt);
  544.         break;
  545. case 28:            /* quit */
  546.         tvclr();
  547.         remark("Exit");
  548.         goto lquit;
  549. case 29:            /* search again */
  550.         succ = search(lexcnt,FALSE); /* FALSE => don't read search string */
  551.         break;
  552. case 30:            /* execute repeat buffer again */
  553.         if (lexcnt != 1)
  554.         echof=FALSE;    /* turn off echo */
  555.         rptcnt[rptuse] = lexcnt > 0 ? lexcnt : (-lexcnt);
  556.         break;
  557. case 31:            /* print memory status, etc. */
  558.         memory();
  559.         break;
  560. case 32:            /* change a parameter */
  561.         setpar(lexcnt);
  562.         break;
  563. case 33:            /* remove last and enter insert mode */
  564.         if ((succ = rmvlst()))
  565.         succ = insert(1,TRUE);
  566.         break;
  567. case 34:            /* unkill last line killed */
  568.         succ = unkill();
  569.         break;
  570. case 35:            /* jump over a word */
  571.         wordr(lexcnt);
  572.         break;
  573. case 36:            /* neg jump over word */
  574.         wordr(-lexcnt);
  575.         break;
  576. case 37:            /* append to save buffer */
  577.         succ = save(lexcnt,TRUE);
  578.         break;
  579. case 38:            /* print screen */
  580.         scrprint();
  581.         break;
  582. case 39:            /* show repeat buffer + help*/
  583.         shoset();
  584.         break;
  585. case 40:            /* flip screen half page */
  586.         dwnlin( min((lexcnt*tvlins)/2 , nxtlin-curlin+1) );
  587.         break;
  588. case 41:            /* abort */
  589.         abort();
  590.         break;
  591. case 42:            /* change characters */
  592.         if ((succ = delnxt(lexcnt)))
  593.         succ = insert(1,TRUE);
  594.         break;
  595. case 43:            /* jump back to last location */
  596.         itmp = curlin;
  597.         curlin = lastln;
  598.         curchr = *(lines+curlin)+1;    /* point to the current character */
  599.         verify(1);
  600.         lastln = itmp;
  601.         break;
  602. case 44:            /* tidy up screen */
  603.         succ = neaten(lexcnt);
  604.         break;
  605. case 45:            /* save current location */
  606.         if (lexcnt < 1 || lexcnt > 9)
  607.         lexcnt = 0;
  608.         noteloc[lexcnt] = curlin;
  609.         break;
  610. case 46:            /* return to noted location */
  611.         itmp = curlin;
  612.         if (lexcnt < 1 || lexcnt > 9)
  613.         lexcnt = 0;
  614.         if (noteloc[lexcnt] >= nxtlin)
  615.           {
  616.         tverrb("Line no longer there ");
  617.         noteloc[lexcnt] = curlin;
  618.           }
  619.         else
  620.           {
  621.         curlin = noteloc[lexcnt];
  622.         curchr = *(lines+curlin)+1; /* point to the current character */
  623.         verify(1);
  624.         lastln = itmp;
  625.           }
  626.         break;
  627.  
  628. case 47:
  629.         opsystem();        /* call operating system */
  630.         break;
  631.  
  632. case 48:
  633.         if (lex_def)        /* default 1 passed */
  634.         lexcnt = rptuse + 1;    /* use current repeat loop */
  635.         succ = edit_rpt(lexcnt);    /* edit repeat buffer */
  636.         break;
  637.  
  638. case 49:
  639.         succ = store_rpt(lexcnt);    /* store repeat buffer */
  640.         break;
  641.  
  642. case 50:
  643.         succ = exec_rpt(lexcnt);    /* execute repeat buffer */
  644.         break;
  645.  
  646. case 51:
  647.         succ = ins_pat(lexcnt);
  648.         break;
  649. case 52:
  650.         succ = user_1(lexcnt);    /* user function 1 */
  651.         break;
  652.  
  653. case 53:
  654.         succ = user_2(lexcnt);    /* user function 2 */
  655.         break;
  656.         }              /* end of switch */
  657.         continue;        /* next iteration of do loop */
  658.       } /* end of else */
  659.       } /* end of do loop */
  660.     while (1);
  661.  
  662. lquit:
  663.     for ( wtpage(1) ; rdpage() ; wtpage(1) )    /* write whole file */
  664.     ;
  665.     tvclr();
  666.   }
  667.  
  668. /* =============================>>> EDIT_RPT <<<============================= */
  669.   edit_rpt(val)
  670.   int val;
  671.   {            /* copy repeat buffer val into buffer for editing */
  672.  
  673.     SLOW char *cp;
  674.     SLOW int start_line;
  675.     
  676.     if (val == 0)
  677.     val = rptuse+1;
  678.  
  679.     if (!chk_rpt_nr(val))
  680.         return FALSE;
  681.  
  682.     --val;        /* change to relative */
  683.  
  684.     beglin();        /* start by moving to beginning of current line */
  685.     start_line = curlin;    /* where we started */
  686.  
  687.     
  688.     ins_chr('#'); ins_chr(val+'1'); ins_chr(':');
  689.     /* start with number */
  690.     ins_chr('<');    /* insert start of repeat loop */
  691.  
  692.     for (cp = &rptbuf[val][0] ; *cp ; ++cp)
  693.     ins_chr(*cp);
  694.     ins_chr(27); ins_chr(27);    /* make a way for store_rpt to find end */
  695.  
  696.     ins_chr(CR);        /* terminate line */
  697.     curlin = start_line;
  698.     curchr = *(lines+curlin)+1;
  699.     verify(1);
  700.     
  701.     return (TRUE);
  702.  
  703.   }
  704.  
  705. /* =============================>>> ENDLIN <<<============================= */
  706.   endlin()
  707.   { /* endlin - move cursor to end of the line */
  708.  
  709.     FAST int cnt;
  710.     SLOW BUFFINDEX i;
  711.  
  712.     cnt=0;
  713.     for (i=curchr; *(buff+i)!=ENDLINE; ++i)    /* find end of line */
  714.     ++cnt;
  715.     right(cnt);     /* move to end of line */
  716.   }
  717.  
  718. /* =============================>>> EXEC_RPT <<<============================= */
  719.   exec_rpt(knt)
  720.   int knt;
  721.   {            /* this is combination of k:r,n& */
  722.     static char chr;
  723.     static int val;
  724.  
  725.     if (! grptch(&chr))        /* get buffer # (k) to use */
  726.     return (FALSE);
  727.  
  728.     val = chr - '0';        /* convert to 0 to 9 */
  729.  
  730.     if (!chk_rpt_nr(val))
  731.         return FALSE;
  732.  
  733.     if (val > 0)        /* change to specific buffer */
  734.     rptuse=val-1;    /* adjust for 0 index int */
  735.  
  736.     if (knt != 1)
  737.     echof = FALSE;    /* turn off echo */
  738.  
  739.     rptcnt[rptuse] = knt > 0 ? knt : (-knt);
  740.  
  741.     return (TRUE);
  742.   }
  743.  
  744. /* =============================>>> FINDDL <<<============================= */
  745.   finddl(ibeg,cnt)
  746.   int *ibeg,*cnt;
  747.   {  /* finddl - find the display line
  748.     known: current line, calculate where it would go on the screen */
  749.  
  750.     if (curlin <= dsplin)
  751.       {             /* it is in first part of the display */
  752.     *ibeg = 1;
  753.     *cnt = min(tvlins,nxtlin-1);
  754.     tvdlin = curlin;        /* update the display line */
  755.       }
  756.     else if (nxtlin-curlin <= tvlins-dsplin)    /* at bottom of display */
  757.       {
  758.     *ibeg = max(1,nxtlin-tvlins);
  759.     *cnt = min(tvlins,nxtlin-1);
  760.     tvdlin=min(curlin,tvlins-(nxtlin-curlin)+1);
  761.       }
  762.     else            /* normal case: in middle */
  763.       {
  764.     *ibeg=max(1,curlin-dsplin+1);
  765.     *cnt=min(tvlins,nxtlin-(*ibeg));
  766.     tvdlin=dsplin;
  767.       }
  768.  }
  769.  
  770. /* =============================>>> FINDX  <<<============================= */
  771.   int findx()
  772.   {  /* findx - find the x position of the current character
  773.         handles spacing for tabs, control characters etc */
  774.  
  775.     SLOW BUFFINDEX i;
  776.     SLOW int pos,lmold;
  777.  
  778.     pos = 0;
  779.     for (i = *(lines+curlin)+1; i<=curchr; ++i)
  780.     if (*(buff+i-1)<' ' && *(buff+i-1)>0)  /* cur pos depends on last chr */
  781.         if (*(buff+i-1)==TAB)        /* handle tabs */
  782.         for (++pos ; ((pos-1) % 8)!=0; ++pos)
  783.             ;
  784.         else        /* control characters (echoed as ^X) */
  785.         pos += 2;    /* 2 spaces for other control character */
  786.     else            /* normal character */
  787.         ++pos;
  788.  
  789.     lmold = leftmg;        /* old left margin */
  790.     for (;;)
  791.       {
  792.     if (pos < leftmg)    /* won't fit on screen */
  793.         leftmg -= 16;    /* shift left */
  794.     else if (pos >= tvcols+leftmg)
  795.         leftmg += 16;
  796.     else
  797.         break;
  798.       }
  799.  
  800.     if (leftmg != lmold)        /* this handles screen shift */
  801.     newscr();
  802.  
  803.     return (pos-leftmg+1);
  804.   }
  805.  
  806. /* =============================>>> FIXEND  <<<============================= */
  807.   fixend()
  808.   { /* fixend - fix the error message line */
  809.  
  810.     SLOW int lastl;
  811.  
  812.     lastl = curlin+(tvlins-tvdlin);    /* the last line on the display */
  813.     tvxy(1,tvhardlines);         /* get to last line */
  814.     tvelin();
  815.     if (lastl < nxtlin && tvlins == tvhardlines)  /* only if really there */
  816.     tvtype(lastl,1);        /* write it out */
  817.     if (curlin >= 1)
  818.     tvhdln();            /* restore cursor */
  819.     else
  820.     tvxy(1,1);
  821.    }
  822.  
  823. /* =============================>>> GBGCOL <<<============================= */
  824.   int gbgcol()
  825.   { /* gbgcol - retrieve unused space in buff */
  826.  
  827.     FAST int i;
  828.     SLOW int lastln;
  829.     SLOW BUFFINDEX nxtbad, nxtgud, to, from, whfrom, offset, newlin;
  830.  
  831.     tverrb("Compacting buffer ");    /* let the user know, it might take a while */
  832.     offset = curchr - *(lines+curlin);    /* need to reset curchr later */
  833.  
  834.     for (nxtbad=1 ; *(buff+nxtbad)!=GARBAGE && nxtbad < nxtchr; ++nxtbad)
  835.         ;        /* find first space to free */
  836.     nxtgud=nxtbad;
  837.     lastln = 1;     /* where to start search */
  838.     do
  839.       {
  840.     to=nxtbad;
  841.     for (from=nxtgud; *(buff+from)==GARBAGE && from<nxtchr; ++from)
  842.         ;            /* find the next non-garbage character */
  843.  
  844. /*  nxtbad pts to first junk character,
  845.     nxtgud pts to next possibly good character */
  846.  
  847.     if (from >= nxtchr)
  848.         break;        /* at the end of the buffer */
  849.     whfrom=from;        /* where it came from */
  850.     newlin = to;        /* remember start */
  851.     do
  852.       {
  853.         *(buff+to) = *(buff+from++);    /* copy good stuff up */
  854.       }
  855.     while (*(buff+to++)!=ENDLINE);
  856.  
  857.     nxtbad=to ; nxtgud=from;
  858.  
  859. /*  now find the old line
  860.     following algorithm assumes next line is likely to
  861.     be near the previous line */
  862.  
  863.     for (i=lastln ; i<nxtlin ; ++i)    /* start where last looked */
  864.         if (*(lines+i)==whfrom)
  865.           {
  866.         *(lines+i)=newlin;    /* point to new position */
  867.         if (curlin==i)
  868.             curchr=newlin+offset;    /* fix curchr if need be */
  869.         break;
  870.           }
  871.  
  872.     if (i >= nxtlin)    /* not found in second half */
  873.       {
  874.         for (i=1 ; i < lastln ; ++i)
  875.         if (*(lines+i)==whfrom)
  876.           {
  877.             *(lines+i)=newlin;        /* point to new position */
  878.             if (curlin==i)
  879.             curchr=newlin+offset;    /* fix curchr if need be */
  880.             break;
  881.           }
  882.         if (i >= lastln)        /* make sure we really found it */
  883.           {
  884.         tverrb("Compactor lost. Quit NOW! ");
  885.         for (i=1 ; i < 32000 ; ++i)
  886.             ;
  887.         return (FALSE);
  888.           }
  889.       }
  890.     lastln = i;            /* start at next line down */
  891.       }
  892.     while (nxtgud < nxtchr);
  893.  
  894.     for (to=nxtbad ; to<=nxtchr ; )
  895.     *(buff+to++)=GARBAGE;
  896.  
  897.     nxtchr=nxtbad;            /* update the next free character */
  898.     tverr("Compactor done");
  899.     return (nxtsav-nxtchr >= 50);
  900.  }
  901.  
  902. /* =============================>>> GETSAV <<<============================= */
  903.   int getsav()
  904.   { /* ## getsav - get text from save buffer */
  905.  
  906.     FAST int to,from;
  907.     SLOW BUFFINDEX fromch;
  908.     SLOW int newlin;
  909.  
  910.     if (mxbuff-nxtsav+savlin >= nxtsav-nxtchr)    /* g.c. */
  911.     if (!gbgcol())
  912.       {
  913.         tverrb("No get room ");
  914.         return (FALSE);
  915.       }
  916.  
  917.     if (nxtsav==mxbuff)        /* nothing to save */
  918.       {
  919.     return (TRUE);
  920.       }
  921.  
  922.     if (mxbuff-nxtsav+savlin >= nxtsav-nxtchr || mxline-nxtlin <= savlin)
  923.       {             /* room to get save buffer? */
  924.     tverrb("No get room ");
  925.     return (FALSE);        /* no room to save */
  926.       }
  927.  
  928. /* check if in middle of line */
  929.     if (curchr > lines[curlin]+1)
  930.     ins_chr(CR);
  931.  
  932. /*   # move down line to make space for new */
  933.     from=nxtlin-1;
  934.     nxtlin=nxtlin+savlin;
  935.     to=nxtlin-1;
  936.     while (from >= curlin)    /* copy line ptrs down right amnt. */
  937.     *(lines+(to--)) = *(lines+(from--));
  938.  
  939.     newlin=curlin;        /* will insert new lines here */
  940.     curlin=to+1;
  941.     fromch = mxbuff;        /* where taking saved stuff from */
  942.     for ( ; newlin < curlin; ++newlin)
  943.       {
  944.     *(buff+nxtchr)=BEGLINE;    /* insert begline character */
  945.     *(lines+newlin) = nxtchr++; /* update line ptrs to new line */
  946.     do            /* copy stuff from save buffer */
  947.       {
  948.         *(buff+nxtchr++) = *(buff+fromch);
  949.       }
  950.     while (*(buff+fromch--));
  951.       }
  952.     oldlen=0;
  953.     savlen=savlin;
  954.     newscr();
  955.     return (TRUE);
  956.   }
  957.  
  958. /* =============================>>> GRPTCH <<<============================= */
  959.   int grptch(chr)
  960.   char *chr;
  961.   { /* grptch - gets a char from repeat buffer or gkbd */
  962.  
  963.     SLOW char tmpchr;
  964.  
  965.     if (rptcnt[rptuse]>0)    /* need to fetch from repeat buffer */
  966.     if (nxtrpt[rptuse] > lstrpt[rptuse])
  967.       {
  968.         return (FALSE);
  969.       }
  970.     else
  971.       {
  972.         *chr=rptbuf[rptuse][nxtrpt[rptuse]];
  973.         ++nxtrpt[rptuse];
  974.       }
  975.     else
  976.       {
  977.     gkbd(&tmpchr);    /* read the character from the keyboard */
  978.     *chr=tmpchr;
  979.       }
  980.     return (TRUE);
  981.   }
  982.  
  983. /* =============================>>> ins_pat  <<<============================= */
  984.   ins_pat(lexcnt)
  985.   int lexcnt;
  986.   {
  987.     SLOW char *chrp;
  988.  
  989.     if (!*pat_buff)
  990.     return (FALSE);
  991.     for (chrp = pat_buff ; *chrp ; )    /* simply insert pattern buffer */
  992.       {
  993.     if (!ins_chr(*chrp++))    /* make sure it works */
  994.         return (FALSE);
  995.       }
  996.  
  997.     return (TRUE); 
  998.   }
  999.  
  1000. /* =============================>>> save_pat  <<<============================= */
  1001.   save_pat()
  1002.   {  /* save the find pattern, based on oldlen */
  1003.  
  1004.     SLOW int i;
  1005.     SLOW char *chrp;
  1006.  
  1007.     
  1008.     if (oldlen <= 0)
  1009.       {
  1010.     pat_buff[0] = 0;
  1011.     return;                /* nothing to save */
  1012.       }
  1013.  
  1014.     for (i = 1 ; i <= oldlen ; ++i)    /* first, move left */
  1015.       {
  1016.     --curchr;
  1017.     if (*(buff+curchr) == BEGLINE)
  1018.       {
  1019.         if (curlin > 1)
  1020.           {
  1021.         --curlin;
  1022.         for (curchr = *(lines+curlin) ; *(buff+curchr)!=ENDLINE ;
  1023.           ++curchr)
  1024.             ;        /* bump curchr to end of the line */
  1025.           }
  1026.         else
  1027.           {
  1028.         ++curchr;
  1029.         break;
  1030.           }
  1031.       }
  1032.       }
  1033.  
  1034.      /* now save, go back right */
  1035.  
  1036.     chrp = pat_buff;            /* put in pattern buffer */
  1037.  
  1038.     for (i = 1 ; i <= oldlen ; ++i)
  1039.       {
  1040.     if (*(buff+curchr)==ENDLINE)
  1041.       {
  1042.         if (curlin+1 >= nxtlin)
  1043.         break;        /* don't go beyond end! */
  1044.         ++curlin;
  1045.         curchr = *(lines+curlin)+1;
  1046.         *chrp++ = CR;    /* make a cr */
  1047.       }
  1048.     else
  1049.       {
  1050.         if ((chrp - 100) < pat_buff)    /* make sure enough room */
  1051.         *chrp++ = *(buff+curchr);
  1052.         ++curchr;
  1053.       }
  1054.       }
  1055.     *chrp = 0;                    /* terminate */
  1056.   }
  1057.  
  1058. /* =============================>>> INSET <<<============================= */
  1059.   inset(val,set)
  1060.   int val,*set;
  1061.   {
  1062.      /* return true if val is in set set */
  1063.  
  1064.     while (*set)
  1065.     if (val == *set++)
  1066.         return TRUE;
  1067.     return FALSE;
  1068.   }
  1069.  
  1070. /* =============================>>> ins_chr <<<============================= */
  1071.   ins_chr(ival)
  1072.   int ival;
  1073.   {
  1074.     return insert(ival,FALSE);        /* force insert */
  1075.   }
  1076.  
  1077. /* =============================>>> INSERT <<<============================= */
  1078.   insert(ival,how)
  1079.   int ival,how;
  1080.   { /* insert - insert a character
  1081.  
  1082.     if how is TRUE, then read characters from keyboard until
  1083.     get an escape, otherwise insert ival */
  1084.  
  1085.     SLOW BUFFINDEX from,to;
  1086.     SLOW BUFFINDEX curbuf,curend;
  1087.     SLOW int lenins, nocins, ityp, xf;
  1088.     SLOW BUFFINDEX abvchr;
  1089.  
  1090.     SLOW char chr;
  1091.  
  1092.  
  1093.     static int ins_msg = TRUE;    /* own variable */
  1094.  
  1095.     if (ins_msg)
  1096.         csrins();        /* change cursor */
  1097.  
  1098.     if (how)        /* how = 1 regular insert mode */
  1099.       {
  1100.     if (! grptch(&chr))    /* get char using grptch */
  1101.         goto l9999;
  1102.     if (chr == ESC)        /* esc means done */
  1103.       {
  1104.         goto l1000;
  1105.       }
  1106.       }
  1107.     else
  1108.     chr = ival;        /* use the passed value */
  1109.  
  1110.     if (chr==ENDLINE || chr==BEGLINE || chr==GARBAGE || (chr==ENDFILE && usecz))
  1111.     goto l9998;        /* don't allow this case! */
  1112.  
  1113.     if (curlin < 1)
  1114.       {             /* buffer empty? */
  1115.     curlin=1;        /* init for initial insert */
  1116.     *(lines+1)=nxtchr;
  1117.     curchr=nxtchr+1;
  1118.     *(buff+nxtchr)=BEGLINE;
  1119.     *(buff+nxtchr+1)=ENDLINE;
  1120.     nxtchr += 2;
  1121.     nxtlin = 2;
  1122.       }
  1123.  
  1124.     lenins=0;            /* remember length of insert for rmvlst */
  1125.  
  1126.     do
  1127.       {
  1128.     if (nxtsav-nxtchr < ALMOSTOUT)
  1129.         if (!gbgcol())
  1130.         goto l9999;    /* collect garbage if necessary */
  1131.     curbuf = *(lines+curlin);  /* pick up the pointer to current line */
  1132.     for (curend=curbuf; *(buff+curend)!=ENDLINE; ++curend)
  1133.         ;            /* get line length */
  1134.     if (curend+1 < nxtchr)    /* not using last part of buffer */
  1135.       {
  1136.         if (curend-curbuf >= nxtsav-nxtchr)
  1137.         goto l9998;    /* no more room! */
  1138.         curchr=nxtchr+(curchr-curbuf);    /* where curchr will be */
  1139.         *(lines+curlin)=nxtchr;    /* new line goes here */
  1140.         stcopy(buff,curbuf,buff,&nxtchr); /* copy the line to the end */
  1141.         curend=nxtchr++;    /* reset end pointer */
  1142.         kline(curbuf);    /* kill off the line */
  1143.         curbuf = *(lines+curlin);    /* update beginning pointer */
  1144.       }
  1145.  
  1146. /*   #    to here, ready to insert the new character at the end of the line */
  1147.  
  1148.     if (chr==' ' && wraplm > 1 && (tvx >= wraplm || leftmg > 1))    /* auto wrap? */
  1149.           chr = CR;
  1150. #ifdef FILELF
  1151.     if (chr == LF && how)
  1152.         ;            /* don't insert lfs in CR/LF systems, echo? */
  1153.     else if (chr == CR)    /* inserting a new line */
  1154. #else
  1155.     if (chr == CR)        /* inserting a new line */
  1156. #endif
  1157.       {
  1158.         if (nxtlin >= mxline)    /* any room? */
  1159.           {
  1160.         tverrb("No more free lines for insert ");
  1161.         goto l9999;
  1162.           }
  1163.  
  1164.         for (from=curend; from >= curchr; --from)
  1165.         *(buff+from+2) = *(buff+from);        /* copy chars down */
  1166.         nxtchr += 2;    /* bump nxtchr to free space */
  1167.  
  1168.         *(buff+curchr) = ENDLINE;    /* mark as endline */
  1169.         *(buff+curchr+1) = BEGLINE;    /* beginning of line */
  1170.         ++lenins;
  1171.  
  1172.         to=nxtlin;        /* move lines down */
  1173.         for (from = nxtlin-1; from > curlin; )
  1174.           {         /* bump the lines down */
  1175.         *(lines+to--) = *(lines+from--);
  1176.           }
  1177.         ++nxtlin;    /* bump to next free line */
  1178.  
  1179.         *(lines+curlin+1)=curchr+1;        /* remember where */
  1180.  
  1181.         if (ins_msg)
  1182.             fixend();                /* fix last line */
  1183.         tvelin();    /* erase stuff after cr */
  1184.  
  1185.         nocins = (leftmg > 1);    /* ciline no good if left marg > 1 */
  1186.  
  1187.         dwnlin(1);    /* go down one line */
  1188.  
  1189.         if (ciline[0] == 0 || nocins)
  1190.           {
  1191.         tvescr();        /* erase the rest of the screen */
  1192.         ityp = min(tvlins-tvdlin+1,nxtlin-curlin);
  1193.           }
  1194.         else
  1195.           {
  1196.         tvinsl();     /* insert a line */
  1197.         ityp = 1;
  1198.           }
  1199.  
  1200.         tvtype(curlin,ityp);
  1201.         tvhdln();
  1202.         if (ins_msg)
  1203.         csrins();            /* change cursor */
  1204.  
  1205.         if (autoin && curlin > 2)        /* automatic indentation! */
  1206.           {
  1207.         ins_msg = FALSE;        /* turn off insert message */
  1208.         abvchr = *(lines+curlin-1)+1;    /* prevous line */
  1209.         while (*(buff+abvchr)==' ' || *(buff+abvchr)==TAB)
  1210.             if (!insert(*(buff+abvchr++),FALSE) )
  1211.               {
  1212.             ins_msg = TRUE;
  1213.             goto l9999;
  1214.               }
  1215.             else if (ttymode)        /* hmm, now what? */
  1216.               {
  1217.             ttymode = FALSE;
  1218.             ttwt(*(buff+abvchr-1));
  1219.             ttymode = TRUE;
  1220.               }
  1221.         ins_msg = TRUE;
  1222.         fixend();
  1223.         csrins();            /* change cursor */
  1224.           }
  1225.       }
  1226.     else if (chr == delkey && how)
  1227.       {
  1228.         if (!delnxt(-1))    /* rubbing out last character */
  1229.         goto l9999;
  1230.         --lenins;
  1231.       }
  1232.     else            /* inserting on the current line */
  1233.       {
  1234.         to = nxtchr;        /* will move to nxtchr */
  1235.         for (from = curend ; from >= curchr; )
  1236.           {
  1237.         *(buff+to--) = *(buff+from--);
  1238.           }
  1239.         curend=nxtchr++;    /* end is now at curchr, bump nxtchr */
  1240.         *(buff+curchr)=chr;    /* stick in the current character */
  1241.         ++lenins;
  1242.         if (tvlins < tvhardlines - 10)
  1243.           {
  1244.         tvelin();
  1245.         ctrlch(chr);
  1246.         ctrlch('+');
  1247.           }
  1248.         else
  1249.             tvtyln(curchr);    /* retype rest of the line */
  1250.         ++curchr;        /* reset the curchr pointer */
  1251.         xf = findx();
  1252.         tvxy(xf,tvy);    /* reset the cursor */
  1253.       }
  1254.  
  1255. /* the character has been inserted and displayed, get another maybe */
  1256.  
  1257.     if (how)
  1258.         if (!grptch(&chr))
  1259.         goto l9999;
  1260.       }
  1261.     while (how && chr != ESC);    /* end of do */
  1262.  
  1263.     if (tvlins < tvhardlines - 10)        /* fix for slow baud */
  1264.       {
  1265.     tvelin();
  1266.         tvtyln(curchr);    /* retype rest of the line */
  1267.     xf = findx();
  1268.     tvxy(xf,tvy);    /* reset the cursor */
  1269.       }
  1270.  
  1271.     oldlen = lenins;
  1272.     savlen = (-1);        /* haven't saved lines */
  1273.     goto l1000;
  1274.  
  1275. l9998:
  1276.     tverrb("Can't insert that char ");
  1277. l9999:
  1278.     csrcmd();
  1279.     return FALSE;
  1280. l1000:
  1281.  
  1282.     if (ins_msg)
  1283.         fixend();
  1284.     csrcmd();
  1285.     return TRUE;
  1286.  }
  1287. /* ------------------------ tvx_1.c ------------------------------------- */
  1288.